"""
日期处理类
"""

import time
import datetime

class MZ_Date(object):
    def __init__(self):
        super(MZ_Date, self).__init__()

    def getToday(self):
        today=time.strftime("%Y-%m-%d")
        return today

    def getWeekday(self, int_year, int_month, int_day):
        '''
        获取星期几
        :return:
        '''
        # 这是获取当前星期
        # a=time.localtime()
        # # d=time.strftime("%A",a)
        # w=time.strftime("%w",a)

        weekday = datetime.datetime(int_year, int_month, int_day).strftime("%w")
        # print(weekday)
        if weekday == '0':
            return 7
        else:
            return int(weekday)
    def getStrWeekday(self,date):
        '''
        根据日期返回当前中文星期名称
        :param date:
        :return:
        '''
        datelist = date.split('-')
        year = datelist[0]
        month = datelist[1]
        day = datelist[2]
        int_year = self.str2int(year)
        int_month = self.str2int(month)
        int_day = self.str2int(day)
        weekday_list=['周日','周一','周二','周三','周四','周五','周六']
        num=int(datetime.datetime(int_year, int_month, int_day).strftime("%w"))
        return weekday_list[num]

    def isWeekend(self, date):
        '''
        该函数用来判断给定日期是否为周末.
        :param date: 格式类似 2019-06-05
        :return:
        '''
        datelist = date.split('-')
        year = datelist[0]
        month = datelist[1]
        day = datelist[2]
        int_year = self.str2int(year)
        int_month = self.str2int(month)
        int_day = self.str2int(day)

        weekday = self.getWeekday(int_year, int_month, int_day)
        if weekday == 7:
            return True
        else:
            return False

    def isLeapyear(self, year):
        """
        判定是否为闰年
        :param year:
        :return:
        """
        if (year % 4) == 0:
            if (year % 100) == 0:
                if (year % 400) == 0:
                    # print("{0} 是闰年".format(year))  # 整百年能被400整除的是闰年
                    return True
                else:
                    # print("{0} 不是闰年".format(year))
                    return False
            else:
                # print("{0} 是闰年".format(year))  # 非整百年能被4整除的为闰年
                return True
        else:
            # print("{0} 不是闰年".format(year))
            return False

    def isMonth31(self, month):
        '''
        判定该月是否为3月
        :param month:
        :return:
        '''
        have31 = ['01', '03', '05', '07', '08', '10', '12']
        if month in have31:
            return True
        else:
            return False

    def getMonthDayCount(self, int_year, int_month):
        '''
        该函数获取给定月的所有日期数
        :param int_year:
        :param int_month:
        :return:
        '''
        day31 = [1, 3, 5, 7, 8, 10, 12]

        if int_month == 2:
            if self.isLeapyear(int_year):  # 当是闰年时
                return 29
            else:
                return 28

        elif int_month in day31:
            return 31
        else:
            return 30

    ####计算函数
    def get_current_week(self):
        """
        返回当前时间的上一周的开始和结束时间
        """
        now = datetime.datetime.now()
        this_week_start = now - datetime.timedelta(days=now.weekday())
        this_week_end = now + datetime.timedelta(days=6 - now.weekday())

        return this_week_start.strftime("%Y-%m-%d"), this_week_end.strftime("%Y-%m-%d")

    def getWeekStartAndEnd(self,date):
        """
        传入指定日期，返回该日期所在周的起始日期与结束日期
        :param year:
        :param month:
        :param day:
        :return:
        """
        year,month,day = date.split('-')
        target_date = datetime.date(int(year),int(month),int(day))
        week_start = target_date - datetime.timedelta(days=target_date.weekday())
        week_end = target_date + datetime.timedelta(days=6 - target_date.weekday())

        return week_start.strftime("%Y-%m-%d"), week_end.strftime("%Y-%m-%d")

    def getWeekDates(self, date):
        """
        获取某日所在整周日期列表
        :param date:
        :return:
        """
        week_start, week_end = self.getWeekStartAndEnd(date)

        date_list = self.getDateList(week_start, week_end)
        return date_list

    def getDateList(self,start_date=None,end_date=None):
        """
        给定任意2个日期返回其中之间的所有日期
        :param start_date:
        :param end_date:
        :return:
        """
        date_list = []
        begin_date = datetime.datetime.strptime(start_date, "%Y-%m-%d")
        end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
        while begin_date <= end_date:
            date_str = begin_date.strftime("%Y-%m-%d")
            date_list.append(date_str)
            begin_date += datetime.timedelta(days=1)
        return date_list


    def get_last_week(self):
        """
        获取上周起始与结束日期
        :return:
        """
        now = datetime.datetime.now()
        last_week_start = now - datetime.timedelta(days=now.weekday() + 7)
        last_week_end = now - datetime.timedelta(days=now.weekday() + 1)

        return last_week_start.strftime("%Y-%m-%d"), last_week_end.strftime("%Y-%m-%d")

    def get_next_week(self):
        """
        获取下周起始与结束日期
        :return:
        """
        now = datetime.datetime.now()
        next_week_start = now - datetime.timedelta(days=now.weekday() - 7)
        next_week_end = now - datetime.timedelta(days=now.weekday() - 13)
        return next_week_start.strftime("%Y-%m-%d"), next_week_end.strftime("%Y-%m-%d")

    def get_current_month(self):
        """
        计算本月起始与结束日期
        :return:
        """
        now = datetime.datetime.now()
        next_month = now.month + 1
        year = now.year

        if now.month == 12:
            next_month = 1


        if now.month + 2 >= 13:
            next_month = 1
            year += 1
        next_month_start = datetime.datetime(year, next_month, 1)

        this_month_start = datetime.datetime(now.year, now.month, 1)
        this_month_end = datetime.datetime(year, next_month, 1) - datetime.timedelta(
            days=1) + datetime.timedelta(
            hours=23, minutes=59, seconds=59)

        return this_month_start.strftime("%Y-%m-%d"), this_month_end.strftime("%Y-%m-%d")

    def get_last_month(self):
        """
        计算上月起始与结束日期
        :return:
        """
        now = datetime.datetime.now()
        this_month_start = datetime.datetime(now.year, now.month, 1)
        last_month_end = this_month_start - datetime.timedelta(days=1) + datetime.timedelta(
            hours=23, minutes=59, seconds=59)
        last_month_start = datetime.datetime(last_month_end.year, last_month_end.month, 1)

        return last_month_start.strftime("%Y-%m-%d"), last_month_end.strftime("%Y-%m-%d")

    def get_next_month(self):
        """
        计算下月起始与结束日期
        :return:
        """
        now = datetime.datetime.now()
        next_month = now.month + 1
        year = now.year

        if now.month == 12:
            next_month = 1

        if now.month + 2 >= 13:
            next_month = 1
            year += 1

        next_month_start = datetime.datetime(year, next_month, 1)

        next_month_end = datetime.datetime(year, next_month+1, 1) - datetime.timedelta(
            days=1) + datetime.timedelta(
            hours=23, minutes=59, seconds=59)

        return next_month_start.strftime("%Y-%m-%d"), next_month_end.strftime("%Y-%m-%d")

    def delta_date(self,start_date,end_date):
        """
        计算起始与结束日期长度
        :param start_date:
        :param end_date:
        :return:
        """
        if start_date and end_date:
            start = datetime.datetime.strptime(start_date, "%Y-%m-%d")
            end = datetime.datetime.strptime(end_date, "%Y-%m-%d")
            delta_day = (end - start).days
        else :
            delta_day = 1
        return delta_day

    def cross_day(self,start_date,end_date,limit_start,limit_end):
        """
        给定一个日期范围，与一个限定的日期范围，求两日期范围之间相交的日期数
        :param start_date:
        :param end_date:
        :param limit_start:
        :param limit_end:
        :return:
        """
        date_length = self.delta_date(start_date,end_date)+1
        #
        # compare_start = self.delta_date(start_date, limit_start)
        # compare_end = self.delta_date(end_date, limit_end)000000
        # if  >0: # 说明日期起始在限制日期之前
        #
        #     if self.delta_date(s)





    def getPerSunday(self, int_year, int_month):
        '''
        该函数根据提供的年、月来获取该月每个星期日
        :param int_year: 2019
        :param int_month: 6
        :return: 因为不能通用，所以返回一个元组，一个是数值，一个具体日期
        （[2,9,16,23,30],['2019-06-02', '2019-06-09', '2019-06-16', '2019-06-23', '2019-06-30']）

        这里有BUG,当本月的日期数大于最后的周的日期数时，该超出周的日期应该算在下一周，而不能算在本周，所以
        当用该函数获取的每月周数是对的，但是不能直接用于最大最近比较，还得考虑当超出最后一周的日期时，就用最后
        一周的日期作为最近日期,其实这时候就可以用 self.weekOne2Date_list来获取。
        '''
        daylist = []
        sundayList = []
        daycount = self.getMonthDayCount(int_year, int_month)
        for i in range(1, daycount + 1):
            weekday = datetime.datetime(int_year, int_month, i).strftime("%w")
            if weekday == '0':
                daylist.append(i)
                date = self.int2str(int_year) + '-' + self.int2str(int_month) + '-' + self.int2str(i)
                sundayList.append(date)

        return (daylist, sundayList)

    def getLastMonthDay(self, year, month):
        month31 = [1, 3, 5, 7, 8, 10, 12]  # 这些月有31天，其实可以把3去掉，但没关系
        if month == 3:  # 主要判断给定月是不是3月即可知道上月是不是2月
            # 当是3月时，则要判定是不是闰年
            if self.isLeapyear(year):  # 当是闰年时
                return 29

            else:
                return 28

        else:  # 不是三月的话，那么判定该月的上一月是不是31天即可
            if month in month31:  # 在上月是2月排除的情况下，如果给定月是属于31天组，那么上月就只能是30天
                return 31

            else:
                return 30

    def getLastMonth(self, month):
        '''
        给定month获取上一个月的month
        :param month:
        :return:
        '''
        if month == 1:
            return 12
        else:
            return month - 1

    def getNextMonth(self, int_month):
        '''
        获取给定月份下一个月分
        :param month:
        :return:
        '''
        if int_month == 12:
            return 1
        else:
            return int_month + 1

    def str2int(self, str_day):
        '''
        将当前日数转成整数,eg: str 05 => int 5
        :param day:
        :return:
        '''
        if str_day.startswith('0'):
            return int(str_day[1:])
        else:
            return int(str_day)

    def int2str(self, day):
        '''
        如果day小于10，则返回加0字符串
        :param day:
        :return:
        '''
        if day < 10:
            return '0' + str(day)
        else:
            return str(day)

    def getNearYearList(self):
        """
        根据今日来获取最近前后20年值
        :return:
        """
        today=self.getToday()
        year=today.split('-')[0]
        int_year=int(year)
        near_before_years=int_year-20
        near_after_years=int_year+20

        return [str(y) for y in range(near_before_years,near_after_years)]

    def getMonthDayList(self,int_year,int_month):
        """
        给定年份与月份，返回当前月份里的所有日期
        :param year :整数 year
        :param month:整数 month
        :return:
        """
        month_all_day_list=[]
        month_count =self.getMonthDayCount(int_year,int_month)#返回当前月数
        format_month=self.int2str(int_month)
        for i in range(1,month_count+1):
            format_i=self.int2str(i)
            day='{}-{}-{}'.format(int_year,format_month,format_i)
            month_all_day_list.append(day)

        return month_all_day_list





    def weekOne2Date_list(self, date):
        '''
        日期分析算法:
        1.获取当前的日期
        2.得到今天星期几
        3.得到这周星期一，到给定日期为止的所有日期数（难点在 跨月份）
        :param date: 给定的日期，一般是今天，但是可能那帮2b会手动输入指定截取日期
        :return: 一个列表，包含这周的所有日期，eg:如果输入是2019-06-01则返回 ['2019-05-27','2019-05-28','2019-05-29','2019-05-30','2019-05-31','2019-06-01']
        注：如果要查询上周的信息必须查询上周星期日

        拆分步骤3的算法。如果查询星期为星期日，日期为7，则查询一周为 01-07，星期一到星期日，
        如果查询星期为星期日，日期为06，则查询一周为 上月的28,29，30或者31 到这月的06号，所以判断临界点D是日期是否为06，
        算法如下：
        *****
        假设查询日期为D.星期为W, 年份Y，月份M
        if int(D)>6:
            查询的一周起始日期为D-W+1,注意要日期格式化，当数字小于等于9时，前面加0，dateFormate(D-W+1)
            结果为：[Y-M-dateFormate(int(D)-W+1),..., Y-M-D]
        else:

        if Y为闰年:

            其实都可以通用，既然我们拿到了指定月的数值，我们只需要知道上月是不是2月，如果是2月，那是不是闰年二月即可，
            上月末日期数L+int(D)-W+1 ，eg: 三月 ，星期6 ，日期为02，则 这周第一天为：28+2-6+1=25，



        '''

        # com=re.compile('(.*-)(.*)(-.*)')
        # g = com.match(date)
        #
        # year=g.group(1) #给定年
        # month=g.group(2)#给定月
        # day=g.group(3)#给定日
        splitDate = date.split("-")
        year = splitDate[0]
        month = splitDate[1]
        day = splitDate[2]

        # 先拿星期W
        int_year = int(year)
        int_month = self.str2int(month)
        D = self.str2int(day)  # 拿到日期数-> D
        # print(D)
        W = self.getWeekday(int_year, int_month, D)
        # print(W)

        # 拿个上月日期
        last_month = self.getLastMonth(int_month)  # 这里还是整数

        # 获取上月月末日期数L，这里有问题，现在只是考虑跨月情况，还有非跨月情况，所以用SD来表示起始日期，当前指定日期D
        # 当起始日期SD>D时，表示跨月了，然后进行下面操作，如果没跨月，那么就是D-W+1,或者直接使用D>6来判定，
        weekday_list = []
        if D > 6:  # 当非跨月时
            SD = D - W + 1
            for i in range(SD, D + 1):
                date = year + '-' + month + '-' + self.int2str(i)
                weekday_list.append(date)

        else:  # 当跨月时
            L = self.getLastMonthDay(int_year, int_month)  # 先获取上月的月末日期

            # 然后得到周起始日期
            SD = L + D - W + 1

            # 然后分开2次循环，一个是上月的循环，一个该月循环，最后加入一起
            for k in range(SD, L + 1):
                date = year + '-' + self.int2str(last_month) + '-' + self.int2str(k)
                weekday_list.append(date)

            for g in range(1, D + 1):
                date = year + '-' + month + '-' + self.int2str(g)
                weekday_list.append(date)
        # 到此获取到了，给定日期，拿到当前日期所在周一到该日期的日期列表

        return weekday_list

    # MZ_Date类实现 日期的操作，关键是获取当前周周一到指定日的所有日期analysisDate，以及生成当月每周日期getPerSunday
    # analysisDate很灵活，但是适用于实时计算，而且缺点是，如果有人获取非星期天的数量时，会出现计算不完整的情况。
    # 所以用于统计的话，最好能定时生成每周的数据，可以每天刷新当周数据，

    # 方案有2个：
    # 方法一，直接指定任意日期，然后获取当前日期所在整周的所有日期列表
    # 方法二，直接指定任意月份，可以选择第几周,因为每月的周数量不靠谱，所以个人觉得用第一种
    # 而且有给定任意年月，可以获取到每月的周末具体日期，所以可以对接方法一

    def getWeeklist(self, date):
        '''
        该函数是给定日期，获取给定日期所在的一整周的所有日期列表，这里可以用来在前端当前页显示本周的总数据
        这里注意跨月
        :param date: eg: 2019-06-01
        :return:  eg: ['2019-05-27','2019-05-28','2019-05-29','2019-05-30','2019-05-31','2019-06-01','2019-06-02']
        '''
        datelist = date.split('-')
        year = datelist[0]
        month = datelist[1]
        day = datelist[2]
        int_year = self.str2int(year)
        int_month = self.str2int(month)
        int_day = self.str2int(day)

        weekend_list = self.getPerSunday(int_year, int_month)[0]

        if int_day <= weekend_list[-1]:  # 当日期在该月最后一个星期前，属于未跨月

            closestDay = self.getClosestDay(int_day, weekend_list)
            sunday = year + '-' + month + '-' + self.int2str(closestDay)

            weekont2date = self.weekOne2Date_list(sunday)
            return weekont2date

        else:  # 当跨月时，该日期所在周必然是下一个月的第一周
            nextmonth = self.getNextMonth(int_month)
            next_sunday_list = self.getPerSunday(int_year, nextmonth)[1]
            next_sunday = next_sunday_list[0]
            next_week = self.weekOne2Date_list(next_sunday)
            return next_week

    def getClosestDay(self, d, d_list):
        '''
        该函数获取一个数在一个数列中的最近最大值
        注，这里有个BUG,当给定日大于最大列表数时，其实这日是属于下一周的
        :param d:
        :param d_list:[2,9,16,23,30]
        :return:
        '''
        closeDay = None
        for i in d_list:
            if i >= d:
                closeDay = i
                break

        if closeDay == None:
            closeDay = d_list[-1]

        return closeDay

    def getMonthAllWeek(self, int_year, int_month):
        '''
        根据给定年月、获取当月所有具体周的所有日期,每周一个列表，返回当月总列表,用来后续计算当月每周数据，
        这个数据可以一天一刷新，存在指定月份位置，然后每次手机调用时，通过给定日期，返回存储的内容
        :param int_year: eg:2019
        :param int_month: eg:6
        :return:eg:[['2019-05-27', '2019-05-28', '2019-05-29', '2019-05-30', '2019-05-31', '2019-06-01', '2019-06-02'],
        ['2019-06-03', '2019-06-04', '2019-06-05', '2019-06-06', '2019-06-07', '2019-06-08', '2019-06-09'],
        ['2019-06-10', '2019-06-11', '2019-06-12', '2019-06-13', '2019-06-14', '2019-06-15', '2019-06-16'],
         ['2019-06-17', '2019-06-18', '2019-06-19', '2019-06-20', '2019-06-21', '2019-06-22', '2019-06-23'],
          ['2019-06-24', '2019-06-25', '2019-06-26', '2019-06-27', '2019-06-28', '2019-06-29', '2019-06-30']]

        '''
        perSunday = self.getPerSunday(int_year, int_month)
        # print(perSunday)
        sun_date = perSunday[1]
        all_date_list = []

        for i in sun_date:
            weeklist = self.getWeeklist(i)
            all_date_list.append(weeklist)
        return all_date_list

    #########下面实现date日期，日增减，周增减，月增减

    def dateAddDay(self, date, deltaDay):#不太准，用dateAdd
        '''
        该函数实现日期日增减，这个有问题,计算超过一个星期就错误！！！
        :param date: 日期
        :param deltaDay: 可以是1或者-1
        :return:
        算法 ： 难度在跨月，跨月就必须分闰年与31天
        '''
        datelist = date.split('-')
        year = datelist[0]
        month = datelist[1]
        day = datelist[2]
        int_year = self.str2int(year)
        int_month = self.str2int(month)
        int_day = self.str2int(day)

        this_month_day_count = self.getMonthDayCount(int_year, int_month)  # 获取本月日期数
        last_month = self.getLastMonth(int_month)  # 获取上一个月份
        next_month = self.getNextMonth(int_month)  # 获取下一个月份

        result_day = int_day + deltaDay  # 计算后的日数
        if result_day > this_month_day_count:  # 跨下月  当该数大于本月最大日期后，转到下一月,  注意跨年
            if int_month > next_month:  # 当本月大于下月时，说明本月是12月,跨年
                next_int_year = int_year + 1
                # next_day='01'
                newDate = str(next_int_year) + '-01-01'
                # newDate=str(next_int_year)+'-'+str(next_month)+'-'+next_day
                return newDate

            else:
                newDate = year + '-' + self.int2str(next_month) + '-' + '01'
                return newDate

        elif result_day < 1:  # 跳上月 当本来就是月初时，这会跳到上一月
            if last_month > int_month:  # 当上月大于本月时，说明本月是1月  ,跨年
                last_int_year = int_year - 1
                newDate = str(last_int_year) + '-12-31'

            else:
                last_month_endDay = self.getLastMonthDay(int_year, int_month)
                newDate = year + '-' + self.int2str(last_month) + '-' + self.int2str(last_month_endDay)
                return newDate
        else:  # 本月
            newDate = year + '-' + month + '-' + self.int2str(result_day)
            return newDate

    def dateAdd(self,start_date,days):
        """
        最正确的日期加法
        :param start_date:
        :param days:
        :return:
        """
        d=datetime.datetime.strptime(start_date,'%Y-%m-%d')
        delta = datetime.timedelta(days=days)
        n_days = d + delta
        return (n_days.strftime('%Y-%m-%d'))


    def date_delta(self, date, deltaDay):#用这个只能28天
        '''
        该函数实现日期的增减，粗暴法，直接给多少差值计算多少差值，暂时只支持最多28天加减
        :param date: 当前日期
        :param delta: 差值日期
        :return:
        算法：分闰年，分日期
        '''
        datelist = date.split('-')
        year = datelist[0]
        month = datelist[1]
        day = datelist[2]
        int_year = self.str2int(year)
        int_month = self.str2int(month)
        int_day = self.str2int(day)

        this_month_day_count = self.getMonthDayCount(int_year, int_month)  # 获取本月日期数

        last_month = self.getLastMonth(int_month)  # 获取上一个月份
        next_month = self.getNextMonth(int_month)  # 获取下一个月份

        result_day = int_day + deltaDay  # 计算后的日数
        if result_day > this_month_day_count:  # 跨下月  当该数大于本月最大日期后，转到下一月,假如是6月28，加7天，28+7=35，35-30=5，就是7月5，注意跨年
            if int_month > next_month:  # 当本月大于下月时，说明本月是12月,跨年
                next_int_year = int_year + 1

                new_day = result_day - this_month_day_count
                # newDate = str(next_int_year) +'-'+self.int2str(next_month)+'-'+self.int2str(new_day)
                newDate = str(next_int_year) + '-01-' + self.int2str(new_day)
                return newDate

            else:  # 不跨年

                new_day = result_day - this_month_day_count
                newDate = year + '-' + self.int2str(next_month) + '-' + self.int2str(new_day)
                return newDate

        elif result_day < 1:  # 跳上月 当本来就是月初时，这会跳到上一月,假如是6月02，减7天，2-7=-5，上月31天，31-5=26，就是5月26
            if last_month > int_month:  # 当上月大于本月时，说明本月是1月上月12  ,跨年
                last_int_year = int_year - 1
                new_day = 31 + result_day
                newDate = str(last_int_year) + '-12-' + self.int2str(new_day)
                # print('跨年，上一月')
                return newDate

            else:
                last_month_endDay = self.getLastMonthDay(int_year, int_month)
                new_day = last_month_endDay + result_day
                newDate = year + '-' + self.int2str(last_month) + '-' + self.int2str(new_day)
                # print('不跨年，上一月')
                return newDate
        else:  # 本月
            newDate = year + '-' + month + '-' + self.int2str(result_day)
            return newDate

    ########定制函数

    def getAlldaysInStartEndDay(self,start_date,end_date):
        """
        给定任意2个日期返回其中之间的所有日期
        :param start_date:
        :param end_date:
        :return:
        """
        date_list = []
        begin_date = datetime.datetime.strptime(start_date, "%Y-%m-%d")
        end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
        while begin_date <= end_date:
            date_str = begin_date.strftime("%Y-%m-%d")
            date_list.append(date_str)
            begin_date += datetime.timedelta(days=1)
        return date_list

    def getLast_This_Next_Next_Weeks(self, date):
        '''
        该函数是给定日期，返回上一周，本周，下一周，下下周的总日期列表
        :param date:
        :return: [last_week_list+this_week_list+next_week_list+next_next_week_list]，里面是完整的eg：['2019-06-10',...,'2019-07-04']
        '''

        last_7day = self.date_delta(date, -7)
        next_7day = self.date_delta(date, 7)
        next_14day = self.date_delta(date, 14)
        # next_21day=self.date_delta(date,21)

        last_weeklist = self.getWeeklist(last_7day)
        this_weeklist = self.getWeeklist(date)
        next_weeklist = self.getWeeklist(next_7day)
        next_next_weeklist = self.getWeeklist(next_14day)

        all_weeklist = last_weeklist + this_weeklist + next_weeklist + next_next_weeklist

        return all_weeklist

    def getScheduleDates(self,date):
        '''
        排期表显示日期与中文星期,为了刷新滑动条，要返回当前日期所在索引
        :param date:
        :return: eg (8,2019-07-04\n周四)
        '''
        all_weeklist=self.getLast_This_Next_Next_Weeks(date)
        new_weeklist=[]
        index=all_weeklist.index(date)
        for i in all_weeklist:
            strWeekday=self.getStrWeekday(i)
            new_str_day =i+"\n"+strWeekday
            new_weeklist.append(new_str_day)

        return (index,new_weeklist)
